Esercitazione: Configurare i ruoli di controllo degli accessi in base al ruolo (RBAC) in servizio Azure Kubernetes (AKS) usando Ansible

Articolo
08/13/2024

Importante

Per eseguire i playbook di esempio contenuti in questo articolo, è necessario Ansible 2.8 (o versione successiva).

Il servizio Azure Kubernetes semplifica la distribuzione di un cluster Kubernetes gestito in Azure. Il servizio Azure Kubernetes riduce la complessità e il sovraccarico operativo della gestione di Kubernetes scaricando gran parte di tale responsabilità su Azure. Come servizio Kubernetes ospitato, Azure gestisce automaticamente attività critiche come il monitoraggio dello stato e la manutenzione. I master di Kubernetes sono gestiti da Azure. È possibile gestire solo i nodi agente. In quanto servizio Kubernetes gestito, il servizio Azure Kubernetes è gratuito: si paga solo per i nodi dell'agente all'interno dei cluster e non per i master.

Il servizio Azure Kubernetes può essere configurato per l'uso dell'ID Entra Di Microsoft per l'autenticazione utente. Dopo la configurazione, usare il token di autenticazione Microsoft Entra per accedere al cluster del servizio Azure Kubernetes. Il ruolo Controllo degli accessi in base al ruolo può essere basato sull'identità di un utente o sull'appartenenza a gruppi di Active Directory.

In questo articolo vengono illustrate le operazioni seguenti:

Creare un cluster del servizio Azure Kubernetes abilitato per Microsoft Entra ID
Configurare un ruolo Controllo degli accessi in base al ruolo nel cluster

Prerequisiti

Sottoscrizione di Azure: se non si ha una sottoscrizione di Azure, creare un account gratuito prima di iniziare.

Entità servizio di Azure: creare un'entità servizio, prendere nota dei valori seguenti: appId, displayName, password e tenant.

Installare Ansible: eseguire una delle opzioni seguenti:
- Installare e configurare Ansible in una macchina virtuale Linux
- Configurare Azure Cloud Shell e, se non si ha accesso a una macchina virtuale Linux, creare una macchina virtuale con Ansible.

Installare la libreria OpenShift di RedHat - pip install openshift

Configurare l'ID Microsoft Entra per l'autenticazione del servizio Azure Kubernetes

Quando si configura Microsoft Entra ID per l'autenticazione del servizio Azure Kubernetes, vengono configurate due applicazioni Microsoft Entra. Questa operazione deve essere completata da un amministratore tenant di Azure. Per altre informazioni, vedere Integrare Microsoft Entra ID con il servizio Azure Kubernetes.

Richiedere i valori seguenti all'amministratore del tenant di Azure:

Segreto dell'app server
ID app server
ID app client
ID tenant

Questi valori sono necessari quando si esegue il playbook di esempio.

Creare un cluster del servizio Azure Kubernetes

In questa sezione viene creato un servizio Azure Kubernetes con l'applicazione Microsoft Entra.

Quando si usa il playbook di esempio, è necessario tenere conto di alcuni concetti fondamentali:

Il playbook carica ssh_key da ~/.ssh/id_rsa.pub. Per modificare, usare il formato a riga singola che inizia con "ssh-rsa" (senza virgolette).
I valori client_id e client_secret vengono caricati da ~/.azure/credentials, cioè il file credenziali predefinito. È possibile impostare questi valori sull'entità servizio o caricarli dalle variabili di ambiente:
```
client_id: "{{ lookup('env', 'AZURE_CLIENT_ID') }}"
client_secret: "{{ lookup('env', 'AZURE_SECRET') }}"
```

Salvare il playbook seguente come 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"

Ottenere l'ID oggetto Microsoft Entra

Per creare un'associazione RBAC, è prima necessario ottenere l'ID oggetto Microsoft Entra.

Accedere al portale di Azure.
Nel campo di ricerca nella parte superiore della pagina immettere Microsoft Entra ID.
Fare clic su Enter.
Nel menu Gestione selezionare Utenti.
Nel campo del nome cercare l'account.
Nella colonna Nome selezionare il collegamento dell'account.
Nella sezione Identità copiare l'ID oggetto.

Creare l'associazione RBAC

In questa sezione viene creato un binding del ruolo o un binding del ruolo cluster nel servizio Azure Kubernetes.

Salvare il playbook seguente come 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>

Sostituire il segnaposto con l'ID <your-aad-account>oggetto tenant di Microsoft Entra.

Il playbook seguente distribuisce il nuovo ruolo nel servizio Azure Kubernetes. Salvarlo come aks-kube-deploy.yml:

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

Eseguire il playbook di esempio

Questa sezione riporta il playbook di esempio completo che chiama le attività create in questo articolo.

Salvare il playbook seguente come 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

vars Nella sezione sostituire i segnaposto seguenti con le informazioni di Microsoft Entra:

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

Per eseguire il playbook completo, usare il comando ansible-playbook:

ansible-playbook aks-rbac.yml

Verificare i risultati

In questa sezione si usa kubectl per elencare i nodi creati in questo articolo.

Immettere il comando seguente a un prompt del terminale:

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

Il comando consentirà di accedere direttamente a una pagina di autenticazione. Accedere con l'account Azure.

Dopo l'autenticazione, kubectl elenca i nodi in modo analogo ai risultati seguenti:

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

Pulire le risorse

Quando non sono più necessarie, eliminare le risorse create in questo articolo.

Salvare il codice seguente come 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"

Eseguire il playbook con ansible-playbook

ansible-playbook cleanup.yml

Passaggi successivi

Ansible in Azure

Condividi tramite