Controllo degli accessi in base al ruolo (RBAC) in Kubernetes

Su questa pagina

Prerequisiti
Cosa faremo?
Crea un file oggetto Ruolo, Associazione ruolo, Ruolo cluster, Associazione ruolo cluster.
Crea un oggetto Ruolo, Associazione ruolo, Ruolo cluster, Associazione ruolo cluster.
Fornisci l'accesso agli utenti utilizzando il file kubeconfig(config).
1. Riepilogo della creazione del file Kubeconfig
Il controllo degli accessi in base al ruolo (RBAC) viene utilizzato per assegnare l'accesso a un computer o alle risorse di rete nel cluster Kubernetes.
In questo articolo, comprenderemo le basi del controllo degli accessi in base al ruolo e creeremo oggetti Role, ClusterRole, RoleBinding e ClusterRoleBinding.
Creeremo quindi un file kubeconfig per concedere un accesso limitato a un particolare utente su uno spazio dei nomi selezionato.
Ma prima di procedere, capiamo prima le basi.
1. Un Ruolo o ClusterRole contiene un insieme di autorizzazioni.
2. Un ruolo imposta le autorizzazioni all'interno di un particolare spazio dei nomi e ClusterRole è una risorsa senza spazio dei nomi.
3. Un'associazione di ruolo concede le autorizzazioni definite in un ruolo a un utente o a un insieme di utenti mentre ClusterRoleBinding concede l'accesso a tutto il cluster
4. Un RoleBinding può fare riferimento a qualsiasi ruolo nello stesso spazio dei nomi. In alternativa, un RoleBinding può fare riferimento a un ClusterRole e associare tale ClusterRole allo spazio dei nomi del RoleBindin
5. Un file kubeconfig è un file utilizzato per configurare l'accesso a Kubernetes dallo strumento a riga di comando kubectl.
Per comprendere in dettaglio RBAC, visita la documentazione ufficiale di Kubernetes qui.
```
Note: Refer screenshots to avoid any confusion before executing the commands. (  = user machine)
```
Prerequisiti
1. Cluster Kubernetes con almeno 1 nodo di lavoro.
  Se vuoi imparare a creare un cluster Kubernetes, fai clic qui. Questa guida ti aiuterà a creare un cluster Kubernetes con 1 master e 2 nodi su istanze AWS Ubuntu EC2.
Che cosa faremo?
1. Crea file oggetto Ruolo, Associazione ruoli, Ruolo cluster, Associazione ruoli cluster.
2. Crea oggetti Role, Role Binding, Cluster Role, Cluster Role Binding nel cluster.
3. Fornisci l'accesso agli utenti utilizzando il file kubeconfig.
4. Riepilogo della creazione del file kubeconfig.
Crea un file oggetto Ruolo, Associazione ruolo, Ruolo cluster, Associazione ruolo cluster.
Crea un file per creare un ruolo nello spazio dei nomi \predefinito\ che può essere utilizzato per concedere l'accesso get, watch ed list ai pod.
```
vim my-role.yml
```
```
kind: Role
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  namespace: default
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]
```
Crea un nuovo file per creare un RoleBinding che consente il ruolo \pod-reader\ all'utente \jane\ all'interno dello spazio dei nomi \default\.
```
vim my-role-binding.yml
```
```
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: read-pods
  namespace: default
subjects:
- kind: User
  name: jane
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io
```
Crea un file per creare un ClusterRole che può essere utilizzato per concedere l'accesso get, watch ed list ai secret in un particolare spazio dei nomi o in tutti gli spazi dei nomi, a seconda di come è associato.
```
vim my-cluster-role.yml
```
```
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: secret-reader
rules:
- apiGroups: [""]
  resources: ["secrets"]
  verbs: ["get", "watch", "list"]
```
Crea un nuovo file per creare un ClusterRoleBinding che consentirà a qualsiasi utente nel gruppo \manager\ di leggere i secret in qualsiasi spazio dei nomi.
```
vim my-cluster-role-binding.yml
```
```
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: read-secrets-global
subjects:
- kind: Group
  name: manager
  apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: secret-reader
  apiGroup: rbac.authorization.k8s.io
```
Crea un oggetto Ruolo, Associazione ruolo, Ruolo cluster, Associazione ruolo cluster.
Ottieni un elenco di ruoli e ruoli cluster esistenti dal cluster.
```
kubectl  get roles
```
```
kubectl  get clusterroles
```
Ottenere un elenco di RoleBinding e ClusterRoleBinding esistenti dal cluster.
```
kubectl  get rolebinding
```
```
kubectl  get clusterrolebinding
```
Ora crea un Role, RoleBinding e ClusterRole ClusterRoleBinding usando i file che abbiamo creato nei passaggi precedenti.
```
kubectl create -f my-role.yml
```
```
kubectl create -f my-role-binding.yml
```
```
kubectl create -f my-cluster-role.yml
```
```
kubectl create -f my-cluster-role-binding.yml
```
Utilizzando i seguenti comandi verificare se gli oggetti sono stati creati.
```
kubectl  get roles | grep pod-reader
```
```
kubectl  get rolebinding | grep read-pods
```
```
kubectl  get clusterroles | grep secret-reader
```
```
kubectl  get clusterrolebinding | grep read-secrets-global
```
Nello screenshot sopra, puoi vedere che Role, RoleBinding e ClusterRole, ClusterRoleBinding è stato creato.
Fornire l'accesso agli utenti utilizzando il file kubeconfig(config).
Ora, in questa sezione, creeremo un file di configurazione che può essere condiviso con un utente. Qui, per testare questo scenario creeremo un utente \bob\ sul server Linux e condivideremo questo file di configurazione con l'utente \bob\. Proveremo quindi a eseguire operazioni consentite e non consentite a quell'utente. Associamo un ClusterRole admin all'utente \bob\ che darà accesso a tutti gli oggetti all'interno dello spazio dei nomi \bob\.
Sui nodi master creare una chiave e una richiesta di firma del certificato (CSR) utilizzando openssl.
```
pwd
```
```
mkdir user-bob
```
```
cd user-bob/
```
```
openssl req -new -newkey rsa:4096 -nodes -keyout bob-k8s.key -out bob-k8s.csr -subj "/CN=bob/O=devops"
```
```
cat bob-k8s.csr | base64 | tr -d '\n'
```
Crea un file di definizione dell'oggetto CertificateSigningRequest contenente il CSR che abbiamo generato nel passaggio precedente. Nel file seguente aggiungi l'output del comando \cat bob-k8s.csr | base64 | tr -d \n\ alla proprietà \request\.
```
vim k8s-csr.yaml
```
```
apiVersion: certificates.k8s.io/v1beta1
kind: CertificateSigningRequest
metadata:
  name: bob-k8s-access
spec:
  groups:
  - system:authenticated
  request: # replace output of: cat bob-k8s.csr | base64 | tr -d '\n'
  usages:
  - client auth
```
```
cat k8s-csr.yaml
```
Crea un oggetto CertificateSigningRequest all'interno di Kubernetes contenente il CSR che abbiamo generato nel passaggio precedente.
```
kubectl  get csr
```
```
kubectl  create -f k8s-csr.yaml
```
```
kubectl  get csr
```
Ora vogliamo approvare l'oggetto CSR (CertificateSigningRequest) che abbiamo creato nel passaggio precedente.
```
kubectl  get csr
```
```
kubectl certificate approve bob-k8s-access
```
```
kubectl  get csr
```
Nello screenshot sopra, puoi vedere che il CSR è stato approvato, rilasciato.
Recupera il certificato disponibile nel campo status.certificate dell'oggetto CSR.
```
ls -lt
```
```
kubectl get csr bob-k8s-access -o jsonpath='{.status.certificate}' | base64 --decode > bob-k8s-access.crt
```
```
ls -lt
```
```
cat bob-k8s-access.crt
```
Recupera il certificato CA del cluster che è il requisito successivo per il file kubeconfig di Bob e salvalo nel file \k8s-ca.crt\.
```
ls -lt
```
```
kubectl config view -o jsonpath='{.clusters[0].cluster.certificate-authority-data}' --raw | base64 --decode - > k8s-ca.crt
```
```
ls -lt
```
```
cat k8s-ca.crt
```
Imposta la configurazione del cluster nel file kubeconfig di Bob. Tutti questi dettagli verranno inseriti dal nostro kubeconfig esistente utilizzando il comando seguente.
```
ls -lt
```
```
kubectl config set-cluster $(kubectl config view -o jsonpath='{.clusters[0].name}') --server=$(kubectl config view -o jsonpath='{.clusters[0].cluster.server}') --certificate-authority=k8s-ca.crt --kubeconfig=bob-k8s-config --embed-certs
```
```
ls -lt
```
```
cat bob-k8s-config
```
Imposta l'utente che importerà la chiave e il certificato di Bob nel file di configurazione.
```
ls -lt
```
```
kubectl config set-credentials bob --client-certificate=bob-k8s-access.crt --client-key=bob-k8s.key --embed-certs --kubeconfig=bob-k8s-config
```
```
ls -lt
```
```
cat bob-k8s-config
```
Crea un contesto per il file di configurazione \Bobs\ utilizzando il seguente comando.
```
ls -lt
```
```
kubectl config set-context bob --cluster=$(kubectl config view -o jsonpath='{.clusters[0].name}') --namespace=bob --user=bob --kubeconfig=bob-k8s-config
```
```
ls -lt
```
```
cat bob-k8s-config
```
Crea uno spazio dei nomi per Bob
```
kubectl  get ns
```
```
kubectl create ns bob
```
```
kubectl  get ns -o wide
```
```
kubectl label ns bob user=bob env=sandbox
```
```
kubectl  get ns -o wide
```
Specifica il contesto che Bob utilizzerà per i suoi comandi kubectl.
```
cat bob-k8s-config
```
```
kubectl config use-context bob --kubeconfig=bob-k8s-config
```
```
cat bob-k8s-config
```
Copia \bob-k8s-config\ dal nodo principale nel file \.kube/config\ nella home directory di Bob e testa il kubeconfig di Bob eseguendo la versione kubectl.
```
vim .kube/config #All the output of "cat bob-k8s-config" command ran on the master node and save it to /home/bob/.kube/config on the user machine.
```
```
kubectl version #Execute this on the user machine
```
Verifica le autorizzazioni eseguendo i seguenti comandi dal computer dell'utente.
```
kubectl  get nodes
```
```
kubectl  get pods
```
```
kubectl  get ns
```
```
kubectl  get deployments
```
```
kubectl  get all
```
Nello screenshot sopra puoi vedere che l'utente \Bob\ non è in grado di eseguire alcuna operazione in quanto non è stato concesso l'accesso.
Assegna a Bob il ruolo predefinito del cluster amministratore per creare la maggior parte dei tipi di oggetti Kubernetes all'interno del suo spazio dei nomi. Questo ruolo \bob-admin\ consentirà l'accesso amministrativo all'utente \Bob\ nello spazio dei nomi \bob\ utilizzando il ClusterRole \admin\.
Esegui il seguente comando sul nodo master.
```
kubectl create rolebinding bob-admin --namespace=bob --clusterrole=admin --user=bob 
```
```
kubectl  get rolebinding
```
```
kubectl  get clusterrole | grep  admin
```
Ottieni gli spazi dei nomi creati per Bob.
Ora, esegui tutti i seguenti comandi dalla macchina dell'utente.
```
kubectl  get ns
```
```
kubectl  get ns bob
```
Nello screenshot qui sopra puoi vedere che l'utente \Bob\ non è in grado di elencare le risorse \namespace\.
Crea un pod nello spazio dei nomi \bob\ impostato come spazio dei nomi predefinito nel file kubeconfig di Bob.
```
kubectl  run nginx --image=nginx
```
```
kubectl  get pods
```
```
kubectl  get pods -o wide
```
Controlla lo spazio dei nomi corrente impostato come spazio dei nomi predefinito
```
kubectl config get-contexts
```
Nello screenshot qui sopra, puoi vedere che \Bob\ è in grado di creare un pod nello spazio dei nomi \bob\ poiché abbiamo associato il ruolo \admin\ all'utente \Bob\ per \bob\ spazio dei nomi.
Prova a creare un pod in uno spazio dei nomi \predefinito\ su cui Bob non dispone di alcuna autorizzazione. Poiché abbiamo consentito all'utente \Bob\ di poter creare oggetti solo nello spazio dei nomi \bob\, l'utente Bob non sarà in grado di creare alcuna risorsa in uno spazio dei nomi diverso da \bob\.
```
kubectl  run nginx-2 --image=nginx --namespace=default
```
Controlla lo spazio dei nomi impostato come spazio dei nomi predefinito nel file kubeconfig. Ciò mostra che lo spazio dei nomi \bob\ è impostato come spazio dei nomi predefinito nel file di configurazione.
```
kubectl config view --minify | grep namespace:
```
Riepilogo della creazione del file Kubeconfig
1. Crea una chiave e una richiesta di firma del certificato (CSR) utilizzando openssl.
2. Crea un file di definizione dell'oggetto CertificateSigningRequest.
3. Crea un oggetto CertificateSigningRequest.
4. Approvare la CSR (CertificateSigningRequest).
5. Recupera il certificato dell'oggetto CSR.
6. Recupera il certificato CA del cluster.
7. Imposta la configurazione del cluster nel file kubeconfig.
8. Imposta l'utente.
9. Crea un contesto.
10. Crea uno spazio dei nomi per l'utente.
11. Specifica il contesto nel file kubeconfig.
12. Trasmetti kubeconfig all'utente.
13. Verifica le autorizzazioni utilizzando il file di configurazione degli utenti
14. Assegna il ruolo all'utente
15. Testa di nuovo le autorizzazioni utilizzando il file di configurazione degli utenti.
Conclusione
In questo articolo, abbiamo visto le basi di Role, RoleBinding e ClusterRole, ClusterRoleBinding, abbiamo anche creato questi oggetti nel nostro cluster. Abbiamo quindi creato un file di configurazione che consente a un determinato utente di eseguire operazioni in un determinato spazio dei nomi. Abbiamo visto come RBAC può aiutarci a limitare l'accesso al cluster Kubernetes.

Controllo degli accessi in base al ruolo (RBAC) in Kubernetes

Su questa pagina

Prerequisiti

Che cosa faremo?

Crea un file oggetto Ruolo, Associazione ruolo, Ruolo cluster, Associazione ruolo cluster.

Crea un oggetto Ruolo, Associazione ruolo, Ruolo cluster, Associazione ruolo cluster.

Fornire l'accesso agli utenti utilizzando il file kubeconfig(config).

Riepilogo della creazione del file Kubeconfig

Conclusione