Tutorial: Konfigurieren von Rollen der rollenbasierten Zugriffssteuerung (RBAC) in Azure Kubernetes Service (AKS) mit AnsibleTutorial: Configure role-based access control (RBAC) roles in Azure Kubernetes Service (AKS) using Ansible

Wichtig

Für die Ausführung der Beispielplaybooks in diesem Artikel ist mindestens Ansible 2.8 erforderlich.Ansible 2.8 (or later) is required to run the sample playbooks in this article.

Mit Azure Kubernetes Service (AKS) können Sie ganz einfach einen Managed Kubernetes-Cluster in Azure bereitstellen.Azure Kubernetes Service (AKS) makes it simple to deploy a managed Kubernetes cluster in Azure. AKS verringert die Komplexität und den operativen Mehraufwand für die Kubernetes-Verwaltung, indem ein Großteil dieser Verantwortung an Azure übertragen wird.AKS reduces the complexity and operational overhead of managing Kubernetes by offloading much of that responsibility to Azure. Azure führt als gehosteter Kubernetes-Dienst wichtige Aufgaben für Sie aus, z.B. Systemüberwachung und Wartung.As a hosted Kubernetes service, Azure handles critical tasks like health monitoring and maintenance for you. Die Kubernetes-Master werden von Azure verwaltet.The Kubernetes masters are managed by Azure. Sie verwalten und warten nur die Agent-Knoten.You only manage and maintain the agent nodes. Als Managed Kubernetes-Dienst ist AKS kostenlos. Sie zahlen nur für die Agent-Knoten in den Clustern, nicht für den Master.As a managed Kubernetes service, AKS is free - you pay only for the agent nodes within your clusters; not for the masters.

AKS kann für die Verwendung von Azure Active Directory (AD) für die Benutzerauthentifizierung konfiguriert werden.AKS can be configured to use Azure Active Directory (AD) for user authentication. Nach der Konfiguration verwenden Sie Ihr Azure AD-Authentifizierungstoken, um sich am AKS-Cluster anzumelden.Once configured, you use your Azure AD authentication token to sign into the AKS cluster. Die rollenbasierte Zugriffssteuerung (RBAC) kann auf der Identität eines Benutzers oder auf der Mitgliedschaft in einer Verzeichnisgruppe basieren.The RBAC can be based on a user's identity or directory group membership.

In diesem Tutorial wird Ansible für Folgendes verwendet:In this tutorial, Ansible is used to:

  • Erstellen eines Azure AD-fähigen AKS-ClustersCreate an Azure AD-enabled AKS cluster
  • Konfigurieren einer RBAC-Rolle im ClusterConfigure an RBAC role in the cluster

VoraussetzungenPrerequisites

  • Azure-Abonnement: Wenn Sie kein Azure-Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.Azure subscription: If you don't have an Azure subscription, create a free account before you begin.
  • Installieren Sie die RedHat OpenShift-Bibliothek - pip install openshift.Install the RedHat OpenShift library - pip install openshift

Konfigurieren von Azure AD für die AKS-AuthentifizierungConfigure Azure AD for AKS authentication

Bei der Konfiguration von Azure AD für die AKS-Authentifizierung werden zwei Azure AD-Anwendungen konfiguriert.When configuring Azure AD for AKS authentication, two Azure AD applications are configured. Dieser Vorgang muss von einem Azure-Mandantenadministrator ausgeführt werden.This operation must be completed by an Azure tenant administrator. Weitere Informationen finden Sie unter Integrieren von Azure Active Directory in Azure Kubernetes Service.For more information, see Integrate Azure Active Directory with AKS.

Beschaffen Sie über den Azure-Mandantenadministrator die folgenden Werte:From the Azure tenant administrator, get the following values:

  • Server-App-GeheimnisServer app secret
  • Server-App-IDServer app ID
  • Client-App-IDClient app ID
  • Mandanten-IDTenant ID

Diese Werte werden zum Ausführen des Beispielplaybooks benötigt.These values are needed to run the sample playbook.

Erstellen eines AKS-ClustersCreate an AKS cluster

In diesem Abschnitt erstellen Sie mit der Azure AD-Anwendung eine AKS-Instanz.In this section, you create an AKS with the Azure AD application.

Hier sind einige wichtige Hinweise aufgeführt, die Sie beim Arbeiten mit dem Beispielplaybook berücksichtigen sollten:Here are some key notes to consider when working with the sample playbook:

  • Das Playbook lädt ssh_key aus ~/.ssh/id_rsa.pub.The playbook loads ssh_key from ~/.ssh/id_rsa.pub. Verwenden Sie bei etwaigen Änderungen das einzeilige Format, und beginnen Sie die Zeile mit „ssh-rsa“ (ohne Anführungszeichen).If you modify it, use the single-line format - starting with "ssh-rsa" (without the quotes).

  • Die Werte client_id und client_secret werden aus ~/.azure/credentials geladen. Dies ist die Standarddatei mit den Anmeldeinformationen.The client_id and client_secret values are loaded from ~/.azure/credentials, which is the default credential file. Sie können diese Werte auf Ihren Dienstprinzipal festlegen oder sie aus Umgebungsvariablen laden:You can set these values to your service principal or load these values from environment variables:

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

Speichern Sie das folgende Playbook als aks-create.yml:Save the following playbook as 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 Azure AD-Objekt-IDGet the Azure AD Object ID

Zum Erstellen einer RBAC-Bindung müssen Sie zuerst die Azure AD-Objekt-ID abrufen.To create an RBAC binding, you first need to get the Azure AD Object ID.

  1. Melden Sie sich beim Azure-Portal an.Sign in to the Azure portal.

  2. Geben Sie im Suchfeld oben auf der Seite Azure Active Directory ein.In the search field at the top of the page, enter Azure Active Directory.

  3. Klicken Sie auf Enter.Click Enter.

  4. Wählen Sie im Menü Verwalten die Option Benutzer.In the Manage menu, select Users.

  5. Suchen Sie im Namensfeld nach Ihrem Konto.In the name field, search for your account.

  6. Wählen Sie in der Spalte Name den Link zu Ihrem Konto aus.In the Name column, select the link to your account.

  7. Kopieren Sie im Abschnitt Identität die Objekt-ID.In the Identity section, copy the Object ID.

    Kopieren Sie die Azure AD-Objekt-ID.

Erstellen einer RBAC-BindungCreate RBAC binding

In diesem Abschnitt erstellen Sie eine Rollen- bzw. Clusterrollenbindung in AKS.In this section, you create a role binding or cluster role binding in AKS.

Speichern Sie das folgende Playbook als kube-role.yml:Save the following playbook as 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 &lt;your-aad-account> durch die Objekt-ID Ihres Azure AD-Mandanten.Replace the &lt;your-aad-account> placeholder with your Azure AD tenant Object ID.

Speichern Sie das folgende Playbook, mit dem Ihre neue Rolle in AKS bereitgestellt wird, als aks-kube-deploy.yml:Save the following playbook - that deploys your new role to AKS - as aks-kube-deploy.yml:

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

Ausführen des BeispielplaybooksRun the sample playbook

Dieser Abschnitt enthält das vollständige Beispielplaybook, mit dem die in diesem Artikel erstellten Aufgaben aufgerufen werden.This section lists the complete sample playbook that calls the tasks creating in this article.

Speichern Sie das folgende Playbook als aks-rbac.yml:Save the following playbook as 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 Azure AD-Informationen:In the vars section, replace the following placeholders with your Azure AD information:

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

Führen Sie das vollständige Playbook mit dem Befehl ansible-playbook aus:Run the complete playbook using the ansible-playbook command:

ansible-playbook aks-rbac.yml

Überprüfen der ErgebnisseVerify the results

In diesem Abschnitt nutzen Sie kubectl, um die in diesem Artikel erstellten Knoten aufzulisten.In this section, you use kubectl list the nodes creating in this article.

Geben Sie den folgenden Befehl an einer Terminaleingabeaufforderung ein:Enter the following command at a terminal prompt:

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

Mit dem Befehl gelangen Sie zu einer Authentifizierungsseite.The command will direct you to an authentication page. Melden Sie sich mit Ihrem Azure-Konto an.Sign in with your Azure account.

Nach der Authentifizierung werden die Knoten von kubectl in etwa wie folgt aufgelistet:Once authenticated, kubectl lists the nodes in similar fashion to the following results:

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 RessourcenClean up resources

Löschen Sie die in diesem Artikel erstellten Ressourcen, wenn Sie sie nicht mehr benötigen.When no longer needed, delete the resources created in this article.

Speichern Sie den folgenden Code als cleanup.yml:Save the following code as 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 des Befehls ansible-playbook aus:Run the playbook using the ansible-playbook command:

ansible-playbook cleanup.yml

Nächste SchritteNext steps